#-*- coding: UTF-8 -*-
from pyramid.httpexceptions import HTTPFound
from pyramid.security import remember
from pyramid.security import forget




from scp.modelo.models import DBSession
from scp.modelo.Fase import Fase
from scp.modelo.Tipo_Item import Tipo_Item
from scp.modelo.Item import Item
from scp.modelo.Recurso import Recurso
from scp.modelo.AsignacionRecurso import AsignacionRecurso
from scp.modelo.Usuario import Usuario

from pyramid.response import Response
from pyramid.view import view_config
import json

from pyramid.security import authenticated_userid

import re

#@view_config(renderer='json')
def fases(request):

	print ">>>>>>>>>>>>>Controlador de Fases - Inicio>>>>>>>>>>>>>>"
	
	methodRequest = request.method
	print methodRequest
	
	print '>>>>>>>>>>>>>>request.url<<<<<<<<<<<<<<<<<<<<<<<<<<'
	
	print request.url
	
	
	print '>>>>>>>>>>>>>>>reles_url<<<<<<<<<<<<<<<<<<<'
	
	print '>>>>>>>>>>>>>>request_matchdict<<<<<<<<<<<<'
	
	dicParametros = request.matchdict
	
	print request.matchdict
	print '>>>>>>>>>>>>>>request_matchdict<<<<<<<<<<<<'
	
	
	print "operación"
	print dicParametros.get('operacion')
	print "operación"
	
	if dicParametros.get('operacion') == 'update' or dicParametros.get('operacion') == 'create':
		print 'entre el if de update'
		
		print 'json.loads(request.params[fase])'
		fase = json.loads(request.params['fase'])
		print json.loads(request.params['fase'])
		print 'fase.data'
		faseData = fase.get('data')
		#print rol.get('data')
		print 'fase.data.nombreFase'
		print faseData.get('nombreFase')
		print 'json.loads(request.params[ids_tipos_items])'
		#tipos_items = json.loads(request.params['ids_tipos_items'])
		#print tipos_items
	
	print 'dicParametros.get(operacion).find(?):' 
	print dicParametros.get('operacion').find('?')
	
	
	session = DBSession()
	if dicParametros.get('operacion') == 'view' and request.url.find('?') == -1:
		print 'respondí un diccionario normal'
		return {'content':'Hello!'}	
	elif dicParametros.get('operacion') == 'view':
		proyecId = json.loads(request.params['idProyecto'])
		fasesAll = session.query(Fase).filter_by(proyecto_id=proyecId).order_by('orden').all()
		
		usuarioLogeado = session.query(Usuario).filter_by( username = authenticated_userid(request) ).first()
		
		print '>>fasesAll'
		print fasesAll
		
		fasesArray = []
		for faseIter in fasesAll:
			mostrarTabLineasBase = permitirTabLineasBase(usuarioLogeado, faseIter.id)
			aux = {'idFase': faseIter.id, 'ordenFase':faseIter.orden, 'nombreFase': faseIter.nombre, 
					'descripFase':faseIter.descripcion, 'inicioFase': faseIter.fecha_inicio,
					'finFase': faseIter.fecha_fin, 'observFase':faseIter.observacion,
					'estadoFase': faseIter.estado, 'mostrarTabLineasBase':mostrarTabLineasBase}
			fasesArray.append(aux)
		
		print '>>fasesAll'
		print fasesAll
			
		responseView = Response()
		#responseView.body = json.dumps(dict(success = True, roles = [{'idRol':'1', 'nombreRol': 'hola', 'descripRol':'mundo'}, {'idRol':'2', 'nombreRol': 'chau', 'descripRol':'mundo'}]))
		responseView.body = json.dumps(dict(success = True, fases = fasesArray))
		responseView.content_type = 'application/json'
		print 'respondí con un Responseeeee!!!'
		return responseView
	elif dicParametros.get('operacion') == 'create':
		proyecId = json.loads(request.params['idProyecto'])
		faseExiste = session.query(Fase).filter_by(proyecto_id=proyecId, nombre=faseData.get('nombreFase')).first()
		cantidadFase = session.query(Fase).filter_by(proyecto_id=proyecId).all()
		
		if faseExiste == None:
			
			faseAdd = Fase()
			faseAdd.orden = len(cantidadFase) + 1
			faseAdd.nombre = faseData.get('nombreFase')
			faseAdd.descripcion = faseData.get('descripFase')
			faseAdd.fecha_inicio = faseData.get('inicioFase')
			faseAdd.fecha_fin = faseData.get('finFase')
			faseAdd.observacion = faseData.get('observFase')
			faseAdd.estado = 'INACTIVA'
			faseAdd.proyecto_id = proyecId
			
			proyecId = json.loads(request.params['idProyecto'])
			tiposItems = json.loads(request.params['ids_tipos_items'])
			tipos_itemsArray = []
			
			for idTipoItem in tiposItems:
				tipoItem = session.query(Tipo_Item).filter_by(proyecto_id=proyecId, id=idTipoItem).first()
				tipos_itemsArray.append(tipoItem)
			
			faseAdd.tipos_items = tipos_itemsArray
			
			session.add(faseAdd)	
			
			recurso = Recurso()
			recurso.tipo = "F"
			recurso.fase = faseAdd
			session.add(recurso)
			
			responseCreate = Response()
			responseCreate.body = json.dumps(dict(success = True))
			responseCreate.content_type = 'application/json'
			
		else:
			responseCreate = Response()
			responseCreate.body = json.dumps(dict(success = True, rsp='er', msg = 'El nombre de la Fase ya existe!'))
			responseCreate.content_type = 'application/json'
		
		return responseCreate
		
	elif dicParametros.get('operacion') == 'update':
		fase = json.loads(request.params['fase'])
		proyecID = json.loads(request.params['idProyecto'])
		idsTiposItemsEditar = json.loads(request.params['ids_tipos_items'])
		faseData = fase.get('data')
		print '>>>>>>>>>>>>>>>>>ID del proyecto es'
		print proyecID
		fasesUpdate = session.query(Fase).filter_by(id = faseData.get('idFase')).one()
		
		# todos los tio_item q tiene asignado la fase
		tipoItemAsignados = session.query(Tipo_Item).filter(Tipo_Item.fase_id == faseData.get('idFase')).filter(Tipo_Item.proyecto_id == proyecID).all()
		idstipoItemAsignados = []
		for idstipoItem in tipoItemAsignados:
			aux = idstipoItem.id
			idstipoItemAsignados.append(aux)
			
		print '===========>>> los tiposItems q tiene la fase'
		print idstipoItemAsignados
		
		idsNoAsigTipItems = []
		for itrId in idstipoItemAsignados:
			if not (itrId in idsTiposItemsEditar):
				print '=========>>>>>>> el id del q no fue mas elegido'
				print itrId
				idsNoAsigTipItems.append(itrId)
				
		print '===========>>> los tiposItems q no fueron elegidos en la fase'
		print idsNoAsigTipItems
		
		#atributosUpdate = session.query(Atributo).filter_by(id=atributoData.get('id')).first()
		responseUpdate = Response()
		if fasesUpdate.estado == 'INACTIVA':
			#solo si el estado de la fase es INACTIVO se puede modificar la fecha de inicio
			fasesUpdate.nombre = faseData.get('nombreFase')
			fasesUpdate.fecha_inicio = faseData.get('inicioFase')
			fasesUpdate.fecha_fin = faseData.get('finFase')
			fasesUpdate.descripcion = faseData.get('descripFase')
			fasesUpdate.observacion = faseData.get('observFase')
			
			

			tipos_itemsArray = []
			
			for idTipo_Item in idsTiposItemsEditar:
				print '>>idTipo_Item en el ciclo!!'
				print idTipo_Item
				tipo_item = session.query(Tipo_Item).filter_by(id=idTipo_Item).first()
				tipos_itemsArray.append(tipo_item)
			
			fasesUpdate.tipos_items = tipos_itemsArray
		
			responseUpdate.body = json.dumps(dict(success = True, rsp='ok', msg = 'Edicion Exitosa!'))
		
		elif fasesUpdate.estado == 'ACTIVA':
			
			fasesUpdate.fecha_fin = faseData.get('finFase')
			fasesUpdate.observacion = faseData.get('observFase')
		
			mensaje = 'Edicion Exitosa!'
			for iterNoAsig in idsNoAsigTipItems:
				item = session.query(Item).filter_by(tipoItem_id=iterNoAsig).first()
				if item != None:
					print '========>>>>> entramos xq el tipo de item esta siendo usado'
					print iterNoAsig
					idsTiposItemsEditar.append(iterNoAsig)
					mensaje = 'Algunos Tipos Items ya han sido usados!'
				
		
		
			print 'el nuevo vector de idsTiposItemsEditar es'
			print idsTiposItemsEditar
			tipos_itemsArray = []
			
			for idTipo_Item in idsTiposItemsEditar:
				print '>>idTipo_Item en el ciclo!!'
				print idTipo_Item
				tipo_item = session.query(Tipo_Item).filter_by(id=idTipo_Item).first()
				tipos_itemsArray.append(tipo_item)
			
			fasesUpdate.tipos_items = tipos_itemsArray
		
			
			responseUpdate.body = json.dumps(dict(success = True, rsp='ok', msg = mensaje))
			
		else:
			responseUpdate.body = json.dumps(dict(success = True, rsp='ok', msg = 'La Fase NO puede ser Editada!'))
		
		#atributosUpdate.tipo_dato = atributoData.get('datoAtributo')
		
		#responseUpdate.body = json.dumps(dict(success = True))
		responseUpdate.content_type = 'application/json'
		return responseUpdate
############################################################################################################		
		
	elif dicParametros.get('operacion') == 'destroy':
		print 'entre en el if de destroy'
		#solo se puede eliminar una fase, si el estado del proyecto es INACTIVO
		
		idFaseEliminar = json.loads(request.params['param_idFase'])
		idProyec = json.loads(request.params['idProyecto'])
		faseEliminar = session.query(Fase).filter_by(proyecto_id= idProyec, id=idFaseEliminar).first()
		
		responseDestroy = Response()
		
		ordenActual = faseEliminar.orden
		if faseEliminar.estado != 'INACTIVA':
			responseDestroy.body = json.dumps(dict(success = True, rsp='ok', msg = 'No puede ser Eliminada por que no tiene Estado INACTIVA!'))
		else:
			#session.query(User).filter("id<:value and name=:name").params(value=224, name='fred').order_by(User.id).one()
			fasesAll = session.query(Fase).filter("orden > :ordenes").params(ordenes=ordenActual).all()
			for faseIter in fasesAll:
				faseIter.orden = faseIter.orden - 1
			
			session.delete(faseEliminar)
			responseDestroy.body = json.dumps(dict(success = True, rsp='ok', msg = 'La Fase ha sido Eliminada!'))
			
		
		
		responseDestroy.content_type = 'application/json'
		return responseDestroy
		
	elif dicParametros.get('operacion') == 'iniciarFase':
		#print 'entre en el if de update'
		
		idIniciarFase = json.loads(request.params['param_ini'])
		inicio_fase = session.query(Fase).filter_by(id=idIniciarFase).first()
		
		responseIniciarFase = Response()
		
		if inicio_fase.estado == 'INACTIVA':
			inicio_fase.estado = 'ACTIVA'
			responseIniciarFase.body = json.dumps(dict(success = True, rsp='ok', msg = 'Se inicio la Fase!'))
		
		elif inicio_fase.estado == 'ACTIVA':
			responseIniciarFase.body = json.dumps(dict(success = True, rsp='ok', msg = 'Ya esta inicializado la Fase!'))
		
		else:	
			responseIniciarFase.body = json.dumps(dict(success = True, rsp='ok', msg = 'La Fase ya fue Terminada!'))
		
		responseIniciarFase.content_type = 'application/json'
		return responseIniciarFase	
	
	
	elif dicParametros.get('operacion') == 'finalizarFase':
		#print 'entre en el if de update'
		
		idFinalizarFase = json.loads(request.params['param_fin'])
		fin_fase = session.query(Fase).filter_by(id=idFinalizarFase).first()
		
		responseFinalizarFase = Response()
		
		if fin_fase.estado == 'ACTIVA':
			fin_fase.estado = 'FINALIZADA'
			responseFinalizarFase.body = json.dumps(dict(success = True, rsp='ok', msg = 'La Fase fue Terminada!'))
		
		elif fin_fase.estado == 'INACTIVA':
			responseFinalizarFase.body = json.dumps(dict(success = True, rsp='ok', msg = 'No puede ser Finalizada por que esta INACTIVA'))
			
		else:
			responseFinalizarFase.body = json.dumps(dict(success = True, rsp='ok', msg = 'Ya finalizó la Fase!'))
		
		
		responseFinalizarFase.content_type = 'application/json'
		return responseFinalizarFase	
		
	elif dicParametros.get('operacion') == 'cambiarFase':
		
		print ('entre a cambiar fase')
		responseCambiar = Response()
		
		proyecId = json.loads(request.params['idProyecto'])
		faseActual = json.loads(request.params['idFaseActual'])
		if (request.params['idFaseContiguo']) != 0:
			print (request.params['idFaseContiguo'])
		fasesCambiarActual = session.query(Fase).filter_by(id = faseActual).one()
		#fasesCambiarActual = session.query(Fase).filter_by(proyecto_id = proyecId, id = faseActual).one()
		cantidadFase = session.query(Fase).filter_by(proyecto_id=proyecId).all()
		
		print ('ANTES de la primera consulta:')
		print ('fasesCambiarActual.orden: ')
		print (fasesCambiarActual.orden)
		
		fasesContiguos = []
		
		if fasesCambiarActual.orden == 1:
			#faseAnterior = session.query(Fase).filter_by(proyecto_id = proyecId, orden = fasesCambiarActual.orden).one()
			fasePosterior = session.query(Fase).filter_by(proyecto_id = proyecId, orden = fasesCambiarActual.orden + 1).one()
			aux1 = {'idFase': fasePosterior.id, 'ordenFase':fasePosterior.orden, 'nombreFase': fasePosterior.nombre}
			fasesContiguos.append(aux1)
		
			
		elif fasesCambiarActual.orden == len(cantidadFase):
			faseAnterior = session.query(Fase).filter_by(proyecto_id = proyecId, orden = fasesCambiarActual.orden - 1).one()
			#fasePosterior = session.query(Fase).filter_by(proyecto_id = proyecId, orden = fasesCambiarActual.orden).one()
			aux = {'idFase': faseAnterior.id, 'ordenFase':faseAnterior.orden, 'nombreFase': faseAnterior.nombre}
			fasesContiguos.append(aux)
			
		else:
			faseAnterior = session.query(Fase).filter_by(proyecto_id = proyecId, orden = fasesCambiarActual.orden - 1).one()
			fasePosterior = session.query(Fase).filter_by(proyecto_id = proyecId, orden = fasesCambiarActual.orden + 1).one()
			aux = {'idFase': faseAnterior.id, 'ordenFase':faseAnterior.orden, 'nombreFase': faseAnterior.nombre}
			fasesContiguos.append(aux)
		
			aux1 = {'idFase': fasePosterior.id, 'ordenFase':fasePosterior.orden, 'nombreFase': fasePosterior.nombre}
			fasesContiguos.append(aux1)
		


		responseCambiar.body = json.dumps(dict(success = True, fases = fasesContiguos))
		responseCambiar.content_type = 'application/json'
		
		return responseCambiar
		
	elif dicParametros.get('operacion') == 'ordenCambiar':
		print ('entre a cambiar fase')
		responseOrdenCambiar = Response()
		
		faseActual = json.loads(request.params['idFaseActual'])
		faseContiguo = json.loads(request.params['idFaseContiguo'])
		
		faseCambiarActual = session.query(Fase).filter_by(id = faseActual).one()
		faseCambiarContiguo = session.query(Fase).filter_by(id = faseContiguo).one()
		
		aux = faseCambiarActual.orden 
		faseCambiarActual.orden = faseCambiarContiguo.orden
		faseCambiarContiguo.orden = aux
		
		print ('estos son los estados DESPUES del cambio:')
		print ('aux: ')
		print (aux)
		print ('fasesCambiarActual.orden: ')
		
		print (faseCambiarActual.orden)
		print ('fasePosterior.orden: ')
		print (faseCambiarContiguo.orden)
		
		
				
		responseOrdenCambiar.body = json.dumps(dict(success = True,))
		responseOrdenCambiar.content_type = 'application/json'
		
		return responseOrdenCambiar

	#if dicParametros.get('operacion') == 'view' and request.url.find('?') == -1:
	#	print 'respondí un diccionario normal'
	#	return {'content':'Hello!'}	
	elif dicParametros.get('operacion') == 'viewTipoItem':
		
		idProyec = json.loads(request.params['idProyecto'])
		tipos_itemsAll = session.query(Tipo_Item).filter_by(proyecto_id=idProyec, fase_id=None).all()
		
		tipos_itemsArray = []
		for tipo_itemIter in tipos_itemsAll:
			aux = {'idTipo_Item': tipo_itemIter.id, 'nombreTipo_Item': tipo_itemIter.nombre, 'descripTipo_Item':tipo_itemIter.descripcion, 'observTipo_Item':tipo_itemIter.observacion}
			tipos_itemsArray.append(aux)
		
		responseView = Response()
		responseView.body = json.dumps(dict(success = True, tipos_items = tipos_itemsArray))
		responseView.content_type = 'application/json'
		
		print 'respondí con un Responseeeee!!!'
		return responseView
	
	elif dicParametros.get('operacion') == 'editarTipoItem':
		
		proyecId = json.loads(request.params['idProyecto'])
		faseEditado = session.query(Fase).filter_by(proyecto_id=proyecId, id=request.params['idFase']).first()
		
		print ">>>id FASE recibido de la vista!!"
		print request.params['idFase']
		
		print '>>>FASE a ser Editado!'
		print faseEditado.nombre
		
		
		tipos_itemsAllEdit = faseEditado.tipos_items
		tipos_itemsArrayEdit = []
		for tipo_itemIter in tipos_itemsAllEdit:
			aux = tipo_itemIter.id
			tipos_itemsArrayEdit.append(aux)	
	
		response = Response()
	
		response.body = json.dumps(dict(success = True, tipo_item = tipos_itemsArrayEdit))
		response.content_type = 'application/json'
		return response

	elif dicParametros.get('operacion') == 'editarFase':
		
		proyecId = json.loads(request.params['idProyecto'])
		tipos_itemsAll = session.query(Tipo_Item).filter_by(proyecto_id=proyecId, fase_id= None).all()
		faseEditado = session.query(Fase).filter_by(proyecto_id=proyecId, id=request.params['idFase']).first()
		#faseEditado = session.query(Fase).filter_by(proyecto_id=proyecId, id=request.params['idFase']).first()
		tiposItemsFases = faseEditado.tipos_items
		
		tipos_itemsArray = []
		for tipo_itemIter in tipos_itemsAll:
			aux = {'idTipo_Item': tipo_itemIter.id, 'nombreTipo_Item': tipo_itemIter.nombre, 'descripTipo_Item':tipo_itemIter.descripcion, 'observTipo_Item':tipo_itemIter.observacion}
			tipos_itemsArray.append(aux)
		
		for tipoItemIter in tiposItemsFases:
			aux = {'idTipo_Item': tipoItemIter.id, 'nombreTipo_Item': tipoItemIter.nombre, 'descripTipo_Item':tipoItemIter.descripcion, 'observTipo_Item':tipoItemIter.observacion}
			tipos_itemsArray.append(aux)
		
		
		responseView = Response()
		responseView.body = json.dumps(dict(success = True, tipos_items = tipos_itemsArray))
		responseView.content_type = 'application/json'
		return responseView
		
	elif dicParametros.get('operacion') == 'verFasesAsignados':
		proyecId = json.loads(request.params['idProyecto'])
		
		fasesAll = session.query(Fase).filter_by(proyecto_id=proyecId).all()
		
		print '>>fasesAll'
		print fasesAll
		
		fasesArray = []
		for faseIter in fasesAll:
			aux = {'idFase': faseIter.id, 'ordenFase':faseIter.orden, 'nombreFase': faseIter.nombre, 
					'descripFase':faseIter.descripcion, 'inicioFase': faseIter.fecha_inicio,
					'finFase': faseIter.fecha_fin, 'observFase':faseIter.observacion,
					'estadoFase': faseIter.estado}
			fasesArray.append(aux)
		
		print '>>fasesAll'
		print fasesAll
			
		responseView = Response()
		responseView.body = json.dumps(dict(success = True, fases = fasesArray))
		responseView.content_type = 'application/json'
		return responseView
		
	elif dicParametros.get('operacion') == 'editarFasesDeRol':
		proyecId = json.loads(request.params['idProyecto'])
		miembroID = json.loads(request.params['id'])
		rolID = json.loads(request.params['idRol'])
		print ('los ids de rol y miembro son:')
		print (rolID)
		print (miembroID)
		
		print ('>>>>>>>>>ahora consulto mi Asignacion de recurso')
		recurAsignadoAll = session.query(AsignacionRecurso).filter(AsignacionRecurso.rol_id == rolID).filter(AsignacionRecurso.usuario_id == miembroID).all()
		print (recurAsignadoAll)
		
		idsRecurAsignado = []
		for iter2 in recurAsignadoAll:
			aux2 = iter2.recurso_id
			idsRecurAsignado.append(aux2)
		
		print ('>>>>>>>>>ahora consulto todas las fases del proyecto')
		fasesAll = session.query(Fase).filter_by(proyecto_id=proyecId).all()
		
		idsFases = []
		for iter in fasesAll:
			aux = iter.id
			idsFases.append(aux)
		
		print ('>>>>>>>>>inicio de la comparacio de recurso y fase')
		idfasesArray = []
		print (idsRecurAsignado)
		for iterRecurso in idsRecurAsignado:
			print ('>>>>>>>>>en el primer for de recurso')
			for iterFase in idsFases:
				print ('>>>>>>>>>consulto el recurso si es igual al de la fase')
				recurso = session.query(Recurso).filter_by(id = iterRecurso).first()
				print ('recurso.fase_id')
				print (recurso.fase_id)
				print ('iterFase')
				print (iterFase)
				if recurso.fase_id == iterFase:
					print ('estoy en if de las fases')
					idfasesArray.append(iterFase)
					break
					
		"""print ('>>>>>>>>>FIN de la comparacion de recurso y fase')
		print (idfasesArray)			
		totalObjetoFases = []	
		for objFase in idfasesArray:
			fase = session.query(Fase).filter_by(id = objFase).first()
			totalObjetoFases.append(fase)
		
		totalFases = []
		for faseIter in totalObjetoFases:
			aux = {'idFase': faseIter.id, 'ordenFase':faseIter.orden, 'nombreFase': faseIter.nombre, 
					'descripFase':faseIter.descripcion, 'inicioFase': faseIter.fecha_inicio,
					'finFase': faseIter.fecha_fin, 'observFase':faseIter.observacion,
					'estadoFase': faseIter.estado}
			totalFases.append(aux)"""
		
		responseEdit = Response()
		responseEdit.body = json.dumps(dict(success = True, fases = idfasesArray))
		responseEdit.content_type = 'application/json'
		return responseEdit
		
		
	elif dicParametros.get('operacion') == 'traerFases':
		proyecId = json.loads(request.params['idProyecto'])
		fasesAll = session.query(Fase).filter_by(proyecto_id=proyecId).all()
		
		fasesArray = []
		
		print ('>>>>>>>ESTOY en traer fases')
		print fasesAll
		for faseIter in fasesAll:
			aux = {'idFase': faseIter.id, 'ordenFase':faseIter.orden, 'nombreFase': faseIter.nombre, 
					'descripFase':faseIter.descripcion, 'inicioFase': faseIter.fecha_inicio,
					'finFase': faseIter.fecha_fin, 'observFase':faseIter.observacion,
					'estadoFase': faseIter.estado}
			fasesArray.append(aux)
			
		responseView = Response()
		responseView.body = json.dumps(dict(success = True, fases = fasesArray))
		responseView.content_type = 'application/json'
		return responseView

def permitirTabLineasBase(usuarioLogeado, idFase):
		session = DBSession()
		#usuarioLogeado = session.query(Usuario).filter_by( username = authenticated_userid(request) ).first()
		#idFase = request.params['idFase']
		recursoFase = session.query(Recurso).filter_by(fase_id = idFase).first()
		asignacionesFase = session.query(AsignacionRecurso).filter_by(recurso_id = recursoFase.id, usuario_id = usuarioLogeado.id).all()
	
		respuesta = False
		done = False
		#rolesUsuario = usuarioLogeado.roles
		for asigFase in asignacionesFase:
			if done:
				break
			for permiso in asigFase.rol.permisos:
				if permiso.nombre == 'VER_LINEA_BASE':
					respuesta = True
					done = True
					break
						
		return respuesta		
			
